home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_11_12 / winroth / xception.h < prev   
Encoding:
C/C++ Source or Header  |  1993-10-20  |  9.8 KB  |  297 lines
  1. /*
  2. ** Exception Library -- General exception handling for ANSI C programs
  3. ** 
  4. ** Copyright (C) 1992 Computational Vision and Active Perception Lab. (CVAP),
  5. **                    Royal Institute of Technology, Stockholm.
  6. **
  7. ** This library is free software; you can redistribute it and/or
  8. ** modify it under the terms of the GNU Library General Public
  9. ** License as published by the Free Software Foundation; either
  10. ** version 2 of the License, or (at your option) any later version.
  11. ** 
  12. ** This library is distributed in the hope that it will be useful,
  13. ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15. ** Library General Public License for more details.
  16. ** 
  17. ** You should have received a copy of the GNU Library General Public
  18. ** License along with this library (see COPYING-LIB); if not, write to 
  19. ** the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, 
  20. ** USA.
  21. ** 
  22. **                            Written by
  23. **
  24. **                   Harald Winroth, Matti Rendahl
  25. **         Computational Vision and Active Perception Laboratory
  26. **            Royal Institute of Technology
  27. **              S-100 44 Stockholm
  28. **                Sweden
  29. **
  30. ** Report bugs to candela-bug@bion.kth.se, and direct all inquiries to 
  31. ** candela@bion.kth.se.
  32. **
  33. */
  34.  
  35. #ifndef EXCEPTION_EXCEPTION_H
  36. #define EXCEPTION_EXCEPTION_H
  37.  
  38. #include <setjmp.h>
  39. #include <stdarg.h>
  40.  
  41. #include <exception/config.h>
  42.  
  43. typedef enum 
  44. { 
  45.     excNoCallback           = 0x0,
  46.  
  47.     excBeginCallback        = 0x1, 
  48.     excEndCallback          = 0x2, 
  49.     excThrowCallback        = 0x4,
  50.     excRecoverCallback      = 0x8,
  51.  
  52.     excCompleteCallback     = excBeginCallback    | \
  53.                           excEndCallback      | \
  54.                   excThrowCallback    | \
  55.                   excRecoverCallback
  56. } excCallbackTag;
  57.  
  58. typedef struct _excBuf 
  59. {
  60.     volatile struct _excBuf *prev, *prev_dynamic;
  61.     unsigned int level;
  62.     unsigned int cb_list_len; 
  63.     unsigned int try_data_sp;
  64.     int in_unwind; /* True if longjmp has been taken */
  65.     jmp_buf buf;
  66.     void *local_try_data[EXC_LOCAL_TRY_DATA_SIZE];
  67.  
  68. } excBuf;
  69.  
  70. typedef void (*excCallback) (excCallbackTag tag, void *cb_data, 
  71.                  void **try_data);
  72. typedef int (*excHandler) (void *e, void *e_type, void *h_data);
  73.  
  74. /* 
  75.  * Place holders (to generate unique addresses) 
  76.  */
  77.  
  78. extern int exc_any; /* Can be used with EXC_INSTALL_HANDLER() */
  79. extern int exc_undefined;
  80.  
  81. #define EXC_ANY (&exc_any)
  82. #define EXC_UNDEFINED (&exc_undefined)
  83.  
  84. /*
  85.  * Functions for manipulating the signal mask saved at the throw-point.
  86.  * If and when the program recovers from the pending exception, this mask
  87.  * will be restored. These functions are equivalent to the SYSV sigsetops(3)
  88.  * but the signal set argument (sigset_t*) is implicit.
  89.  */
  90.  
  91. extern int exc_sigemptyset (void);
  92. extern int exc_sigfillset (void);
  93. extern int exc_sigaddset (int signo);
  94. extern int exc_sigdelset (int signo);
  95. extern int exc_sigismember (int signo);
  96.  
  97. /*
  98.  * Exported functions
  99.  */
  100.  
  101. extern void exc_breakpoint (void); /* Set breakpoints in this dummy function */
  102.  
  103. extern void exc_throw_typed (void *e, void *e_type);
  104. extern void exc_throw (void *e);
  105. extern void exc_rethrow ();
  106.  
  107. extern void *exc_exception (void);
  108. extern void *exc_type (void);
  109.  
  110. extern int exc_in_domain (void *e, void *domain, unsigned long sizeof_domain);
  111. extern int exc_equal (void *e1, void *e2);
  112.  
  113. extern void exc_install_callback (excCallbackTag tags, excCallback cb,
  114.                   void *cb_data);
  115. extern void exc_remove_callback (excCallbackTag tags, excCallback cb,
  116.                  void *cb_data);
  117.  
  118. extern void exc_install_handler (void *e, unsigned long e_size, 
  119.                  excHandler h, void *h_data);
  120. extern void exc_remove_handler (void *e, unsigned long e_size, excHandler h, 
  121.                 void *h_data);
  122.  
  123.  
  124. /*
  125.  * Private -- don't use these in application programs
  126.  */
  127.  
  128. extern volatile excBuf *exc_current_buf;
  129.  
  130. extern volatile excBuf exc_buf;  /* Dummy */
  131. extern char exc_in_try;          /* Dummy */
  132. extern char exc_in_tret;         /* Dummy */
  133. extern char exc_in_unwind;       /* Dummy */
  134. extern char exception;           /* Dummy */
  135.  
  136. extern void *exc_malloc (unsigned long size);
  137. extern void *exc_calloc (unsigned long count, unsigned long size);
  138. extern void *exc_realloc (void *s, unsigned long size);
  139. extern void exc_free (void *s);
  140. extern char *exc_strdup (char *s);
  141.  
  142. extern void exc_vfatal (char *format, va_list list);
  143. extern void exc_fatal (char *format, ...);
  144. extern void exc_panic (void);
  145. extern void exc_assertion_failed (char *file, int line);
  146.  
  147. #define EXC_ASSERT(condition) \
  148.     if (!(condition)) exc_assertion_failed (__FILE__, __LINE__);
  149.  
  150. extern void exc_begin (volatile excBuf *buf, int inside_try);
  151. extern void exc_end (volatile excBuf *buf);
  152. extern int exc_tret (volatile excBuf *buf, int in_tret, char *file, int line);
  153.  
  154. extern void exc_break_in_try_err (char *file, int line);
  155. extern void exc_rethrow_err (char *file, int line);
  156. extern int exc_catch_outside_unwind_err (char *file, int line);
  157. extern void exc_ret_in_try_err (char *file, int line);
  158. extern int exc_tret_err (char *file, int line);
  159.  
  160. #if 0 /* Run-time overhead */
  161. #define EXC_IN_TRY (exc_in_try) 
  162. #define EXC_IN_TRET (exc_in_tret)
  163. #define EXC_IN_UNWIND (exc_in_unwind)
  164. #else
  165. #define EXC_IN_TRY (sizeof (exc_in_try) > 1)
  166. #define EXC_IN_TRET (sizeof (exc_in_tret) > 1)
  167. #define EXC_IN_UNWIND (sizeof (exc_in_unwind) > 1)
  168. #endif
  169.  
  170. #define return switch (EXC_IN_TRY ?                            \
  171.     exc_tret (&exc_buf, EXC_IN_TRET, __FILE__, __LINE__) : 0)                 \
  172.     default: return 
  173.  
  174. /*
  175.   Note: In tryreturn() below, the argument 'X' must be an lvalue. 
  176.         The (0 ? &(X) : 0) expression returns a NULL pointer of X's type.
  177.     The ((char *) &(X)) expression evaluates 'X' in the current TRY 
  178.     scope, which is important if 'X' contains an expression that might
  179.     throw an exception, such as 'idx()' in 'array[idx()]'.
  180. */
  181.  
  182. #define tryreturn(X) /* Note: X must be a lvalue */                  \
  183.     do {                                      \
  184.         long exc_in_tret = EXC_IN_TRY ? 1 : exc_tret_err (__FILE__, __LINE__);\
  185.         char *exc_tret_tmp = (char *) &(X);                      \
  186.         return (0 ? &(X) : 0)                              \
  187.             [(exc_tret_tmp-(char *)0)/sizeof(X)];                  \
  188.     } while(0)
  189.  
  190. #define TRY(TRYFORMS, CATCHFORMS)                          \
  191.     do {                                      \
  192.         volatile excBuf exc_buf;                          \
  193.         exc_begin (&exc_buf, EXC_IN_TRY);                      \
  194.         {                                      \
  195.         long exc_in_try = 1;                          \
  196.                                           \
  197.         if (EXC_SETJMP (exc_buf.buf) == 0)                              \
  198.         {                                      \
  199.         exc_current_buf = &exc_buf;                      \
  200.                                           \
  201.         do {                                  \
  202.             switch (0) { default: { TRYFORMS ; } continue; }          \
  203.             exc_break_in_try_err (__FILE__, __LINE__);              \
  204.             exc_in_try++; /* Not reached */                  \
  205.         } while (0);                              \
  206.                                           \
  207.         exc_end (&exc_buf);                          \
  208.         }                                      \
  209.         else {                                  \
  210.         do {                                  \
  211.             void *exception = exc_exception ();                  \
  212.             long exc_in_unwind = 1;                      \
  213.                                               \
  214.             switch (0)                              \
  215.             {                                  \
  216.             default:                              \
  217.             EXC_ASSERT (exc_current_buf == &exc_buf);          \
  218.             { CATCHFORMS ; }                      \
  219.             THROW (exception);                      \
  220.             }                                  \
  221.             exc_break_in_try_err (__FILE__, __LINE__);              \
  222.         } while (0);                              \
  223.                                           \
  224.         exc_end (&exc_buf);                              \
  225.         }                                      \
  226.     }                                      \
  227.     } while (0)
  228.  
  229. #define EXC_IN_DOMAIN(EXCEPTION, DOMAIN)                      \
  230.     exc_in_domain ((EXCEPTION), & DOMAIN, sizeof (DOMAIN))
  231.  
  232. #define EXC_EQUAL(EXCEPTION, MEMBER)                          \
  233.     exc_equal ((EXCEPTION), & MEMBER)
  234.  
  235. #define CATCH(DOMAIN, FORMS)                              \
  236.     switch (EXC_IN_UNWIND ? EXC_IN_DOMAIN (exc_exception (), DOMAIN)           \
  237.         : exc_catch_outside_unwind_err (__FILE__, __LINE__))          \
  238.     {                                          \
  239.         case 0: break;                                  \
  240.     default: { FORMS ; } continue;                          \
  241.     }
  242.  
  243. #define THROW_TYPED(EXCEPTION, TYPE)                          \
  244.     if ((void *) & EXCEPTION == (void *) & exception)                  \
  245.     {                                          \
  246.         if (EXC_IN_UNWIND)                              \
  247.             exc_rethrow ();                              \
  248.         else                                      \
  249.             exc_rethrow_err (__FILE__, __LINE__);                  \
  250.     }                                          \
  251.     else                                      \
  252.         exc_throw_typed (& EXCEPTION, & TYPE)
  253.  
  254. #define THROW(EXCEPTION) THROW_TYPED (EXCEPTION, EXCEPTION)
  255.  
  256. #define RETHROW() THROW (exception) /* alternative syntax */
  257.  
  258. #define UNWIND_PROTECT(PROTECTEDFORMS, CLEANUPFORMS)                  \
  259.     do {                                      \
  260.     static int _unwind_protect;                          \
  261.                                           \
  262.     TRY (                                      \
  263.     {                                      \
  264.         { PROTECTEDFORMS ; }                          \
  265.         THROW (_unwind_protect);                          \
  266.         },                                      \
  267.     {                                      \
  268.         { CLEANUPFORMS ; }                              \
  269.         CATCH (_unwind_protect, continue);                      \
  270.     }                                      \
  271.          );                                      \
  272.     } while (0)
  273.  
  274. #define EXC_INSTALL_HANDLER(E, HANDLER, HANDLER_DATA)                  \
  275.     exc_install_handler (&E, sizeof (E), (HANDLER), (HANDLER_DATA))
  276.  
  277. #define EXC_REMOVE_HANDLER(E, HANDLER, HANDLER_DATA)                  \
  278.     exc_remove_handler (&E, sizeof (E), (HANDLER), (HANDLER_DATA))
  279.  
  280. /*
  281.  * Note: EXC_LONGJMP must NOT affect the curret signal mask. THROW blocks
  282.  * all signals, and the signals must remain blocked until all unwind code
  283.  * has been executed.
  284.  *
  285.  * The (jmp_buf *) cast is to avoid a type clash: buf is volatile.
  286.  */
  287.  
  288. #if defined(SVR4) || defined(SYSV) || defined(_SYSV_)
  289. #define EXC_SETJMP(buf) setjmp (*(jmp_buf *)&(buf))
  290. #define EXC_LONGJMP(buf, val) longjmp(*(jmp_buf *)&(buf), val)
  291. #else
  292. #define EXC_SETJMP(buf) _setjmp (*(jmp_buf *)&(buf))
  293. #define EXC_LONGJMP(buf, val) _longjmp(*(jmp_buf *)&(buf), val)
  294. #endif
  295.  
  296. #endif /* EXCEPTION_EXCEPTION_H */
  297.